* @param v the vertex to fill
* @param x the x coordinate
* @param y the y coordinate
- * @param z the z coortinate
+ * @param z the z coordinate
* @param n pointer to the normal table
*
* @return the operation error code
</object>
</child>
<child>
- <object class="GtkButton" id="favorite-buttton">
+ <object class="GtkButton" id="favorite-button">
<property name="label" translatable="yes">Favorite</property>
<property name="receives-default">1</property>
<property name="has-frame">0</property>
gtk_get_major_version (),
gtk_get_minor_version (),
gtk_get_micro_version ());
- g_string_append_printf (s, "\nA link can apppear here: <http://www.gtk.org>");
+ g_string_append_printf (s, "\nA link can appear here: <http://www.gtk.org>");
version = g_strdup_printf ("%s\nRunning against GTK %d.%d.%d",
PACKAGE_VERSION,
gtk_media_stream_seek_success (stream);
/* We also have to update our timestamp and tell the
- * paintable interface abbout the seek
+ * paintable interface about the seek
*/
gtk_media_stream_update (stream, nuclear->progress);
gdk_paintable_invalidate_contents (GDK_PAINTABLE (nuclear));
/* This time, we don't have to add a timer here, because media
* streams start paused.
*
- * However, media streams need to tell GTK once they are intialized,
+ * However, media streams need to tell GTK once they are initialized,
* so we do that here.
*/
gtk_media_stream_prepared (GTK_MEDIA_STREAM (nuclear),
gtk_get_major_version (),
gtk_get_minor_version (),
gtk_get_micro_version ());
- g_string_append_printf (s, "\nA link can apppear here: <http://www.gtk.org>");
+ g_string_append_printf (s, "\nA link can appear here: <http://www.gtk.org>");
version = g_strdup_printf ("%s\nRunning against GTK %d.%d.%d",
PACKAGE_VERSION,
### Actions
- - Actions are new in GTK 4, and gtk-doc had to learn a a new syntax
+ - Actions are new in GTK 4, and gtk-doc had to learn a new syntax
to document them:
```
has right gravity, because as you type new text is inserted,
and the cursor ends up on the right.
-The segment itself contains contains a header, plus some
+The segment itself contains a header, plus some
variable-length data that depends on the type of the segment.
The header contains the length of the segment in characters and in
bytes. Some segments have a length of zero. Segments with nonzero
/**
* gdk_device_get_history: (skip)
* @device: a #GdkDevice
- * @surface: the surface with respect to which which the event coordinates will be reported
+ * @surface: the surface with respect to which the event coordinates will be reported
* @start: starting timestamp for range of events to return
* @stop: ending timestamp for the range of events to return
* @events: (array length=n_events) (out) (transfer full) (optional):
/**
* GdkDisplay:composited:
*
- * %TRUE if the display properly composits the alpha channel.
+ * %TRUE if the display properly composites the alpha channel.
* See gdk_display_is_composited() for details.
*/
props[PROP_COMPOSITED] =
*
* Sets a list of backends that GDK should try to use.
*
- * This can be be useful if your application does not
+ * This can be useful if your application does not
* work with certain GDK backends.
*
* By default, GDK tries all included backends.
image_aspect = gdk_paintable_get_intrinsic_aspect_ratio (paintable);
/* If the specified size has neither a definite width nor height,
- * and has no additional contraints, the dimensions of the concrete
+ * and has no additional constraints, the dimensions of the concrete
* object size are calculated as follows:
*/
if (specified_width == 0.0 && specified_height == 0.0)
gdk_surface_event_marshallerv);
/**
- * GdkSurface::enter-montor:
+ * GdkSurface::enter-monitor:
* @surface: the #GdkSurface
* @monitor: the monitor
*
GDK_TYPE_MONITOR);
/**
- * GdkSurface::leave-montor:
+ * GdkSurface::leave-monitor:
* @surface: the #GdkSurface
* @monitor: the monitor
*
* gdk_surface_get_scale_factor:
* @surface: surface to get scale factor for
*
- * Returns the internal scale factor that maps from surface coordiantes
+ * Returns the internal scale factor that maps from surface coordinates
* to the actual device pixels. On traditional systems this is 1, but
* on very high density outputs this can be a higher value (often 2).
*
*
* If granted, the rerouting remains active until the default shortcuts
* processing is restored with gdk_toplevel_restore_system_shortcuts(),
- * or the request is revoked by the desktop enviroment, windowing system
+ * or the request is revoked by the desktop environment, windowing system
* or the user.
*
* A typical use case for this API is remote desktop or virtual machine
* encountered a newly added Vulkan error message.
* You want to add it to this enum now.
*
- * Becuse the Vulkan people don't make adding this too easy, here's
+ * Because the Vulkan people don't make adding this too easy, here's
* the process to manage it:
* 1. go to
* https://github.com/KhronosGroup/Vulkan-Headers/blob/master/include/vulkan/vulkan_core.h
#endif
#if VK_HEADER_VERSION >= 105
case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT:
- return "An operation on a swapchain created with VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT failed as it did not have exlusive full-screen access.";
+ return "An operation on a swapchain created with VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT failed as it did not have exclusive full-screen access.";
#endif
#if VK_HEADER_VERSION >= 131
case VK_ERROR_UNKNOWN:
static int acquired_loop_level = -1;
/* Between run_loop_before_waiting() and run_loop_after_waiting();
- * whether we we need to call select_thread_collect_poll()
+ * whether we need to call select_thread_collect_poll()
*/
static gboolean run_loop_polling_async = FALSE;
/* Current NSEvents that we've gotten from Cocoa but haven't yet converted
* to GdkEvents. We wait until our dispatch() function to do the conversion
- * since the conversion can conceivably cause signals to be emmitted
+ * since the conversion can conceivably cause signals to be emitted
* or other things that shouldn’t happen inside a poll function.
*/
static GQueue *current_events;
************************************************************/
/* The states in our state machine, see comments in select_thread_func()
- * for descriptiions of each state
+ * for descriptions of each state
*/
typedef enum {
BEFORE_START,
case WAITING:
/* Waiting for a set of file descriptors to be submitted by the main thread
*
- * => POLLING_QUEUED: main thread thread submits a set of file descriptors
+ * => POLLING_QUEUED: main thread submits a set of file descriptors
*/
SELECT_THREAD_WAIT ();
break;
*
* If the C library implements posix_fallocate(), it is used to
* guarantee that disk space is available for the file at the
- * given size. If disk space is insufficent, errno is set to ENOSPC.
+ * given size. If disk space is insufficient, errno is set to ENOSPC.
* If posix_fallocate() is not supported, program may receive
* SIGBUS on accessing mmap()'ed file contents instead.
*
_gdk_wayland_display_async_roundtrip (display_wayland);
/* Wait for initializing to complete. This means waiting for all
- * asynchrounous roundtrips that were triggered during initial roundtrip. */
+ * asynchronous roundtrips that were triggered during initial roundtrip. */
while (display_wayland->async_roundtrips != NULL)
{
if (wl_display_dispatch (display_wayland->wl_display) < 0)
geometry_mask &= ~GDK_HINT_RESIZE_INC;
if (!saved_size)
{
- /* Do not reapply contrains if we are restoring original size */
+ /* Do not reapply constrains if we are restoring original size */
gdk_surface_constrain_size (&impl->geometry_hints,
geometry_mask,
width + impl->margin_left + impl->margin_right,
/* This is necessary so that Vulkan sees the Surface.
* Usually, vkCreateXlibSurfaceKHR() will not cause a problem to happen as
- * it just creates resources, but futher calls with the resulting surface
+ * it just creates resources, but further calls with the resulting surface
* do cause issues.
*/
gdk_display_sync (display);
Any operations that require OpenClipboard()/CloseClipboard() combo (i.e.
almost everything, except for WM_RENDERFORMAT handling) is offloaded into
-separate thread, which tries to to complete any operations in the queue.
+separate thread, which tries to complete any operations in the queue.
Each operation routine usually starts with a timeout check (all operations
time out after 30 seconds), then a check for clipboard status (to abort
any operations that became obsolete due to clipboard status being changed -
* GDK will also offer "PNG" and CF_DIB W32 formats.
* * If GTK+ application provides text/plain;charset=utf8, GDK will also offer
* CF_UNICODETEXT (UTF-16-encoded) and CF_TEXT (encoded with thread-
- * and locale-depenant codepage), and will do the conversion when such
+ * and locale-dependent codepage), and will do the conversion when such
* data is requested.
* * If GTK+ application accepts image/png, image/gif or image/jpeg,
* GDK will claim to also accept "PNG", "GIF" or "JFIF" respectively,
return;
/* MSDN is very vague, but in practice rcNormalPosition is the same as GetWindowRect(),
- * only with adjustments for toolbars (which creates rather weird coodinate space issues).
+ * only with adjustments for toolbars (which creates rather weird coordinate space issues).
* We need to get monitor info and apply workarea vs monitorarea diff to turn
* these into screen coordinates proper.
*/
/* This is necessary so that Vulkan sees the Window.
* Usually, vkCreateWin32SurfaceKHR() will not cause a problem to happen as
- * it just creates resources, but futher calls with the resulting surface
+ * it just creates resources, but further calls with the resulting surface
* do cause issues.
*/
gdk_display_sync (display);
gsize n_atoms;
int error;
- /* clipboard managers don't work on anythig but the clipbpoard selection */
+ /* clipboard managers don't work on anything but the clipbpoard selection */
if (!g_str_equal (cb->selection, "CLIPBOARD"))
{
GDK_DISPLAY_NOTE (display, CLIPBOARD, g_printerr ("%s: can only store on CLIPBOARD\n", cb->selection));
{
gint root_x, root_y;
- /* FIXME: Maybe root coords chaching should happen here */
+ /* FIXME: Maybe root coords caching should happen here */
gdk_surface_get_origin (surface, &root_x, &root_y);
_gdk_device_translate_screen_coord (device, surface,
root_x, root_y,
/**
* _gdk_x11_display_screen_for_xrootwin:
* @display: a #GdkDisplay
- * @xrootwin: window ID for one of of the screen’s of the display.
+ * @xrootwin: window ID for one of the screen’s of the display.
*
* Given the root window ID of one of the screen’s of a #GdkDisplay,
* finds the screen.
/* GDK_KEY_ISO_Left_Tab, as usually configured through XKB, really messes
* up the whole idea of "consumed modifiers" because shift is consumed.
* However, <shift>Tab is not usually GDK_KEY_ISO_Left_Tab without XKB,
- * we we fudge the map here.
+ * we fudge the map here.
*/
keycode = keymap_x11->min_keycode;
while (keycode <= keymap_x11->max_keycode)
* fetch of window manager name
*/
guint need_refetch_wm_name : 1;
- guint xft_init : 1; /* Whether we've intialized these values yet */
+ guint xft_init : 1; /* Whether we've initialized these values yet */
guint xft_antialias : 1;
guint xft_hinting : 1;
}
/* Set the property to @utf8_str as STRING if the @utf8_str is fully
- * convertable to STRING, otherwise, set it as compound text
+ * convertible to STRING, otherwise, set it as compound text
*/
static void
set_text_property (GdkDisplay *display,
/* FIXME: This is not part of the EWMH spec!
*
* There is no documented mechanism to remove the property
- * _NET_WM_FULLSCREEN_MONITORS once set, so we use use a set of
+ * _NET_WM_FULLSCREEN_MONITORS once set, so we use a set of
* invalid, largest possible value.
*
* When given values larger than actual possible monitor values, most
/* This is necessary so that Vulkan sees the Window.
* Usually, vkCreateXlibSurfaceKHR() will not cause a problem to happen as
- * it just creates resources, but futher calls with the resulting surface
+ * it just creates resources, but further calls with the resulting surface
* do cause issues.
*/
gdk_display_sync (display);
* | |
* | |
* +-------------------------+
- * That line is equidistant from all sides. It's either horiontal
+ * That line is equidistant from all sides. It's either horizontal
* or vertical, depending on if the rect is wider or taller.
* We use the 4 sides spanned up by connecting the line to the corner
* points to color the regions of the rectangle differently.
*
* The blur radius (which also defines the clip_radius)
*
- * The the horizontal and vertical corner radius
+ * The horizontal and vertical corner radius
*
* We apply the first position and orientation when drawing the
* mask, so we cache rendered masks based on the blur radius and the
* XFree86 4.0 using a set of Perl scripts. Contact Owen Taylor <otaylor@redhat.com>
* to obtain the relevant perl scripts.
*
- * The following compose letter letter sequences confliced
- * Dstroke/dstroke and ETH/eth; resolved to Dstroke (Croation, Vietnamese, Lappish), over
+ * The following compose letter letter sequences conflicted
+ * Dstroke/dstroke and ETH/eth; resolved to Dstroke (Croatian, Vietnamese, Lappish), over
* ETH (Icelandic, Faroese, old English, IPA) [ D- -D d- -d ]
* Amacron/amacron and ordfeminine; resolved to ordfeminine [ _A A_ a_ _a ]
* Amacron/amacron and Atilde/atilde; resolved to atilde [ -A A- a- -a ]
* derive from #GtkAccessible and implement the suitable interfaces
* from ATK, such as #AtkText or #AtkSelection. To establish
* the connection between the widget class and its corresponding
- * acccessible implementation, override the get_accessible vfunc
+ * accessible implementation, override the get_accessible vfunc
* in #GtkWidgetClass.
*/
* been loaded yet, GTK+ tries to find the get_type() function from the
* class name by applying heuristics. This works in most cases, but if
* necessary, it is possible to specify the name of the get_type() function
- * explictly with the "type-func" attribute. As a special case, GtkBuilder
+ * explicitly with the "type-func" attribute. As a special case, GtkBuilder
* allows to use an object that has been constructed by a #GtkUIManager in
* another part of the UI definition by specifying the id of the #GtkUIManager
* in the “constructor” attribute and the name of the object in the “id”
* cell to cell inside the #GtkCellArea. The #GtkCellArea should move
* focus from cell to cell inside the area and return %FALSE if focus
* logically leaves the area with the following exceptions: When the
- * area contains no activatable cells, the entire area recieves focus.
+ * area contains no activatable cells, the entire area receives focus.
* Focus should not be given to cells that are actually “focus siblings”
* of other sibling cells (see gtk_cell_area_get_focus_from_sibling()).
* Focus is set by calling gtk_cell_area_set_focus_cell().
* object is passed to the user function in gtk_cell_layout_set_cell_data_func.
*
* This private api takes gpointer & GFunc arguments to circumvent circular header file
- * dependancies.
+ * dependencies.
*/
void _gtk_cell_area_set_cell_data_func_with_proxy (GtkCellArea *area,
GtkCellRenderer *cell,
* @flags: render flags
* @cell_area: cell area which would be passed to gtk_cell_renderer_render()
* @aligned_area: (out): the return location for the space inside @cell_area
- * that would acually be used to render.
+ * that would actually be used to render.
*
* Gets the aligned area used by @cell inside @cell_area. Used for finding
* the appropriate edit and focus rectangle.
{
gint inset = 0.7 * radius;
- /* transparency is a function of time and intial value */
+ /* transparency is a function of time and initial value */
gdouble t = (gdouble) ((i + num_steps - real_step)
% num_steps) / num_steps;
pango_layout_get_extents (layout, NULL, &rect);
text_width = rect.width;
- /* Fetch the average size of a charachter */
+ /* Fetch the average size of a character */
context = pango_layout_get_context (layout);
metrics = pango_context_get_metrics (context,
pango_context_get_font_description (context),
* @draw_indicator: Whether or not to draw the indicator part of the button
*
* Sets whether the indicator part of the button is drawn. This is important for
- * cases where the check button should have the functinality of a check button,
+ * cases where the check button should have the functionality of a check button,
* but the visuals of a regular button, like in a #GtkStackSwitcher.
*/
void
image_aspect = _gtk_css_image_get_aspect_ratio (image);
/* If the specified size has neither a definite width nor height,
- * and has no additional contraints, the dimensions of the concrete
+ * and has no additional constraints, the dimensions of the concrete
* object size are calculated as follows:
*/
if (specified_width == 0.0 && specified_height == 0.0)
change = gtk_css_static_style_get_change (GTK_CSS_STATIC_STYLE (style));
/* The cache is shared between all children of the parent, so if a
- * style depends on a sibling it is not independant of the child.
+ * style depends on a sibling it is not independent of the child.
*/
if (change & GTK_CSS_CHANGE_ANY_SIBLING)
return FALSE;
* @property: the property
*
* Queries the initial value of the given @property. See the
- * [CSS Documentation](http://www.w3.org/TR/css3-cascade/#intial)
+ * [CSS Documentation](http://www.w3.org/TR/css3-cascade/#initial)
* for an explanation of this concept.
*
* Returns: (transfer none): the initial value. The value will never change.
* text editing widgets, such as #GtkEntry and #GtkSpinButton. It contains functions
* for generically manipulating an editable widget, a large number of action
* signals used for key bindings, and several signals that an application can
- * connect to to modify the behavior of a widget.
+ * connect to modify the behavior of a widget.
*
* As an example of the latter usage, by connecting
* the following handler to #GtkEditable::insert-text, an application
*
* Whenever a container has some form of natural row it may align
* children in that row along a common typographical baseline. If
- * the amount of verical space in the row is taller than the total
+ * the amount of vertical space in the row is taller than the total
* requested height of the baseline-aligned children then it can use a
* #GtkBaselinePosition to select where to put the baseline inside the
- * extra availible space.
+ * extra available space.
*/
typedef enum
{
* left/right of cursor if we’re in the middle of a word.
* @GTK_DELETE_WORDS: Delete words.
* @GTK_DELETE_DISPLAY_LINES: Delete display-lines. Display-lines
- * refers to the visible lines, with respect to to the current line
+ * refers to the visible lines, with respect to the current line
* breaks. As opposed to paragraphs, which are defined by line
* breaks in the input.
* @GTK_DELETE_DISPLAY_LINE_ENDS: Delete only the portion of the
*
* Gets the currently selected option in the 'choice' with the given ID.
*
- * Returns: the ID of the currenly selected option
+ * Returns: the ID of the currently selected option
*/
const char *
gtk_file_chooser_get_choice (GtkFileChooser *chooser,
* The model implements the GtkTreeSortable interface. To avoid re-sorting
* every time a node gets added (which would lead to O(n^2) performance during
* the initial population of the model), the model can freeze itself (with
- * freeze_updates()) during the intial population process. When the model is
+ * freeze_updates()) during the initial population process. When the model is
* frozen, sorting will not happen. The model will sort itself when the freeze
* count goes back to zero, via corresponding calls to thaw_updates().
*/
* @user_data: the model
* @user_data2: GUINT_TO_POINTER of array index of current entry
*
- * All other fields are unused. Note that the array index does not corrspond
+ * All other fields are unused. Note that the array index does not correspond
* 1:1 with the path index as entries might not be visible.
*/
#define ITER_INDEX(iter) GPOINTER_TO_UINT((iter)->user_data2)
* @file: the file to add
* @attributes: attributes to query before adding the file
*
- * This is a conenience function that calls g_file_query_info_async() on
+ * This is a convenience function that calls g_file_query_info_async() on
* the given file, and when successful, adds it to the model.
* Upon failure, the @file is discarded.
**/
* displaying the list of fonts. In GTK+, the main objects
* that implement this interface are #GtkFontChooserWidget,
* #GtkFontChooserDialog and #GtkFontButton. The GtkFontChooser interface
- * has been introducted in GTK+ 3.2.
+ * has been introduced in GTK+ 3.2.
*/
enum
gtk_adjustment_set_upper (gtk_range_get_adjustment (GTK_RANGE (fontchooser->size_slider)),
(gdouble)(G_MAXINT / PANGO_SCALE));
- /* Setup treeview/model auxilary functions */
+ /* Setup treeview/model auxiliary functions */
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (fontchooser->filter_model),
visible_func, (gpointer)fontchooser, NULL);
{
GtkIconTheme *theme;
- /* Get a pointer to the theme, becuse when we unlock it could become NULLed by dispose, this pointer still owns a ref */
+ /* Get a pointer to the theme, because when we unlock it could become NULLed by dispose, this pointer still owns a ref */
theme = ref->theme;
g_mutex_unlock (&ref->lock);
- /* Then unref outside the lock, because otherwis if this is the last ref the dispose handler would deadlock trying to NULL ref->theme */
+ /* Then unref outside the lock, because otherwise if this is the last ref the dispose handler would deadlock trying to NULL ref->theme */
if (theme)
g_object_unref (theme);
g_object_class_install_property (gobject_class, PROP_ICON_NAME,
g_param_spec_string ("icon-name",
P_("Icon name"),
- P_("The icon name choosen during lookup"),
+ P_("The icon name chosen during lookup"),
NULL,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB | G_PARAM_STATIC_NICK));
/**
* a negative value means start before the cursor.
* @n_chars: number of characters to delete.
*
- * Asks the widget that the input context is attached to to delete
+ * Asks the widget that the input context is attached to delete
* characters around the cursor position by emitting the
* GtkIMContext::delete_surrounding signal. Note that @offset and @n_chars
* are in characters not in bytes which differs from the usage other
* XFree86 4.0 using a set of Perl scripts. Contact Owen Taylor <otaylor@redhat.com>
* to obtain the relevant perl scripts.
*
- * The following compose letter letter sequences confliced
- * Dstroke/dstroke and ETH/eth; resolved to Dstroke (Croation, Vietnamese, Lappish), over
+ * The following compose letter letter sequences conflicted
+ * Dstroke/dstroke and ETH/eth; resolved to Dstroke (Croatian, Vietnamese, Lappish), over
* ETH (Icelandic, Faroese, old English, IPA) [ D- -D d- -d ]
* Amacron/amacron and ordfeminine; resolved to ordfeminine [ _A A_ a_ _a ]
* Amacron/amacron and Atilde/atilde; resolved to atilde [ -A A- a- -a ]
*hexpand_p = hexpand;
*vexpand_p = vexpand;
- /* We don't expand vertically beyound the minimum size */
+ /* We don't expand vertically beyond the minimum size */
if (*vexpand_p)
*vexpand_p = FALSE;
}
* GTK sets the default text direction according to the locale
* during gtk_init(), and you should normally use
* gtk_widget_get_direction() or gtk_widget_get_default_direction()
- * to obtain the current direcion.
+ * to obtain the current direction.
*
* This function is only needed rare cases when the locale is
* changed after GTK has already been initialized. In this case,
* gtk_map_list_model_get_model:
* @self: a #GtkMapListModel
*
- * Gets the model that is curently being mapped or %NULL if none.
+ * Gets the model that is currently being mapped or %NULL if none.
*
* Returns: (nullable) (transfer none): The model that gets mapped
**/
/**
* GtkNativeDialog:visible:
*
- * Whether the window is currenlty visible.
+ * Whether the window is currently visible.
*/
native_props[PROP_VISIBLE] =
g_param_spec_boolean ("visible",
*
* This function queries the bookmarks added by the user to the places sidebar,
* and returns one of them. This function is used by #GtkFileChooser to implement
- * the “Alt-1”, “Alt-2”, etc. shortcuts, which activate the cooresponding bookmark.
+ * the “Alt-1”, “Alt-2”, etc. shortcuts, which activate the corresponding bookmark.
*
* Returns: (nullable) (transfer full): The bookmark specified by the index @n, or
* %NULL if no such index exist. Note that the indices start at 0, even though
set_cell_sensitivity_func, NULL, NULL);
- /* Paper size combo auxilary funcs */
+ /* Paper size combo auxiliary funcs */
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (dialog->paper_size_combo),
paper_size_row_is_separator, NULL, NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (dialog->paper_size_combo),
#ifdef QUARTZ_RELOCATION
/* Bundle-based functions for various directories. These almost work
- * even when the application isn’t in a bundle, becuase mainBundle
+ * even when the application isn’t in a bundle, because mainBundle
* paths point to the bin directory in that case. It’s a simple matter
* to test for that and remove the last element.
*/
* a widget upon size-request reports the width and height that it finds
* to be best suited to display its contents, including children.
* the width and/or height reported from a widget upon size requisition
- * may be overidden by the user by specifying a width and/or height
+ * may be overridden by the user by specifying a width and/or height
* other than 0 through gtk_widget_set_size_request().
*
* a scrolled window needs (for implementing all three policy types) to
* request its width and height based on two different rationales.
* 1) the user wants the scrolled window to just fit into the space
- * that it gets allocated for a specifc dimension.
+ * that it gets allocated for a specific dimension.
* 1.1) this does not apply if the user specified a concrete value
* value for that specific dimension by either specifying usize for the
* scrolled window or for its child.
* 2) the user wants the scrolled window to take as much space up as
- * is desired by the child for a specifc dimension (i.e. POLICY_NEVER).
+ * is desired by the child for a specific dimension (i.e. POLICY_NEVER).
*
* also, kinda obvious:
- * 3) a user would certainly not have choosen a scrolled window as a container
+ * 3) a user would certainly not have chosen a scrolled window as a container
* for the child, if the resulting allocation takes up more space than the
* child would have allocated without the scrolled window.
*
* conclusions:
* A) from 1) follows: the scrolled window shouldn’t request more space for a
- * specifc dimension than is required at minimum.
- * B) from 1.1) follows: the requisition may be overidden by usize of the scrolled
+ * specific dimension than is required at minimum.
+ * B) from 1.1) follows: the requisition may be overridden by usize of the scrolled
* window (done automatically) or by usize of the child (needs to be checked).
* C) from 2) follows: for POLICY_NEVER, the scrolled window simply reports the
* child’s dimension.
priv->vscrollbar);
/* If, after the first iteration, the hscrollbar and the
- * vscrollbar flip visiblity... or if one of the scrollbars flip
- * on each itteration indefinitly/infinitely, then we just need both
+ * vscrollbar flip visibility... or if one of the scrollbars flip
+ * on each iteration indefinitely/infinitely, then we just need both
* at this size.
*/
if ((count &&
* gtk_slice_list_model_get_model:
* @self: a #GtkSliceListModel
*
- * Gets the model that is curently being used or %NULL if none.
+ * Gets the model that is currently being used or %NULL if none.
*
* Returns: (nullable) (transfer none): The model in use
**/
* # GtkStack as GtkBuildable
*
* To set child-specific properties in a .ui file, create GtkStackPage
- * objects explictly, and set the child widget as a property on it:
+ * objects explicitly, and set the child widget as a property on it:
* |[
* <object class="GtkStack" id="stack">
* <child>
* @parser: the parser to parse from
*
* Tries to parse the given @property from the given @parser into
- * @value. The type that @value will be assigned is dependant on
+ * @value. The type that @value will be assigned is dependent on
* the parser and no assumptions must be made about it. If the
* parsing fails, %FALSE will be returned and @value will be
* left uninitialized.
}
else if (count > 0)
{
- /* Move to beginning of current word, or if not on a word, begining of next word */
+ /* Move to beginning of current word, or if not on a word, beginning of next word */
start_pos = gtk_text_move_forward_word (self, start_pos, FALSE);
start_pos = gtk_text_move_backward_word (self, start_pos, FALSE);
}
/* And make sure cursors are on screen. Note that the cursor is
* actually drawn one pixel into the INNER_BORDER space on
* the right, when the scroll is at the utmost right. This
- * looks better to to me than confining the cursor inside the
+ * looks better to me than confining the cursor inside the
* border entirely, though it means that the cursor gets one
* pixel closer to the edge of the widget on the right than
* on the left. This might need changing if one changed
*
* The default bindings for this signal come in two variants,
* the variant with the Shift modifier extends the selection,
- * the variant without the Shift modifer does not.
+ * the variant without the Shift modifier does not.
* There are too many key combinations to list them all here.
* - Arrow keys move by individual characters/lines
* - Ctrl-arrow key combinations move by words/paragraphs
* The default bindings for this signal are
* Delete for deleting a character, Ctrl-Delete for
* deleting a word and Ctrl-Backspace for deleting a word
- * backwords.
+ * backwards.
*/
signals[DELETE_FROM_CURSOR] =
g_signal_new (I_("delete-from-cursor"),
GFile *file;
/* Rate limit the updates to not flood the gvfsd-trash when too many changes
- * happended in a short time.
+ * happenned in a short time.
*/
if (monitor->timeout_id > 0)
{
gtk_tree_path_get_indices (dest_row)[0] == 0 &&
gtk_tree_model_iter_n_children (tree_view->model, NULL) != 0)
{
- /* special special case drag to "0", scroll to first item */
+ /* special case drag to "0", scroll to first item */
if (!tree_view->scroll_to_path)
gtk_tree_view_scroll_to_cell (tree_view, dest_row, NULL, FALSE, 0.0, 0.0);
}
}
/* FIXME the bool return values for expand_row and collapse_row are
- * not analagous; they should be TRUE if the row had children and
+ * not analogous; they should be TRUE if the row had children and
* was not already in the requested state.
*/
* gtk_tree_view_get_background_area:
* @tree_view: a #GtkTreeView
* @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
- * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
+ * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates
* @rect: (out): rectangle to fill with cell background rect
*
* Fills the bounding rectangle in bin_window coordinates for the cell at the
* we can correctly account for the indentation. This also means
* that the tooltip is constrained vertically by the "Determine y
* values" code below; this is not a real problem since cells actually
- * don't stretch vertically in constrast to columns.
+ * don't stretch vertically in contrast to columns.
*/
gtk_tree_view_get_cell_area (tree_view, path, column, &tmp);
gtk_tree_view_column_cell_get_position (column, cell, &start, &width);
void gtk_tree_view_set_activate_on_single_click (GtkTreeView *tree_view,
gboolean single);
-/* Column funtions */
+/* Column functions */
GDK_AVAILABLE_IN_ALL
gint gtk_tree_view_append_column (GtkTreeView *tree_view,
GtkTreeViewColumn *column);
/**
* gtk_tree_view_column_cell_set_cell_data:
* @tree_column: A #GtkTreeViewColumn.
- * @tree_model: The #GtkTreeModel to to get the cell renderers attributes from.
- * @iter: The #GtkTreeIter to to get the cell renderer’s attributes from.
+ * @tree_model: The #GtkTreeModel to get the cell renderers attributes from.
+ * @iter: The #GtkTreeIter to get the cell renderer’s attributes from.
* @is_expander: %TRUE, if the row has children
* @is_expanded: %TRUE, if the row has visible children
*
*
* The value used to refer to a guaranteed invalid position in a #GListModel. This
* value may be returned from some functions, others may accept it as input.
- * Its interpretion may differ for different functions.
+ * Its interpretation may differ for different functions.
*
* Refer to each function's documentation for if this value is allowed and what it
* does.
* @target's coordinate system
*
* Translates the given @point in @widget's coordinates to coordinates
- * relative to @target’s coodinate system. In order to perform this
+ * relative to @target’s coordinate system. In order to perform this
* operation, both widgets must share a common root.
*
* Returns: %TRUE if the point could be determined, %FALSE on failure.
}
/* For non-resizable windows, make sure the given width/height fits
- * in the geometry contrains and update the geometry hints to match
+ * in the geometry constrains and update the geometry hints to match
* the given width/height if not.
* This is to make sure that non-resizable windows get the default
* width/height if set, but can still grow if their content requires.
};
/* Some page sizes have multiple PPD names in use.
- * The array above only contails the prefered one,
+ * The array above only contains the preferred one,
* and this array fills out with the duplicates.
*/
const struct {
#ifdef HAVE_COLORD
option = gtk_printer_option_new ("colord-profile",
- /* TRANSLATORS: this this the ICC color profile to use for this job */
+ /* TRANSLATORS: this is the ICC color profile to use for this job */
C_("printer option", "Printer Profile"),
GTK_PRINTER_OPTION_TYPE_INFO);
* @param v the vertex to fill
* @param x the x coordinate
* @param y the y coordinate
- * @param z the z coortinate
+ * @param z the z coordinate
* @param n pointer to the normal table
*
* @return the operation error code
GtkWidget *button10;
window2 = gtk_window_new ();
- gtk_window_set_title (GTK_WINDOW (window2), "\"button 10\" is not inside the horisontal pane");
+ gtk_window_set_title (GTK_WINDOW (window2), "\"button 10\" is not inside the horizontal pane");
gtk_window_set_display (GTK_WINDOW (window2),
gtk_widget_get_display (widget));
gtk_widget_get_allocation (widget, &alloc);
/* Since event coordinates and drawing is supposed to happen in the
- * same coodinates space, this should all work out just fine. */
+ * same coordinates space, this should all work out just fine. */
bounds.origin.x = self->mouse_x;
bounds.origin.y = -30;
bounds.size.width = 1;
gint result;
const char *display, *x_r_d;
- /* These must be set before before gtk_test_init */
+ /* These must be set before gtk_test_init */
g_setenv ("GIO_USE_VFS", "local", TRUE);
g_setenv ("GSETTINGS_BACKEND", "memory", TRUE);
g_setenv ("G_ENABLE_DIAGNOSTIC", "0", TRUE);
* +-----------------+
*
* This is a layout that we also reproduce with
- * constraints, for comparison. Among the contraints:
+ * constraints, for comparison. Among the constraints:
* - child1.width == child2.width
* - child1.height == child2.height == child3.height
*/
int
main (int argc, char *argv[])
{
- /* Don't use gtk_test_init here because it implicitely initializes GTK+. */
+ /* Don't use gtk_test_init here because it implicitly initializes GTK+. */
g_test_init (&argc, &argv, NULL);
gtk_disable_setlocale();
setlocale (LC_ALL, "C");
gint result;
const char *display, *x_r_d;
- /* These must be set before before gtk_test_init */
+ /* These must be set before gtk_test_init */
g_setenv ("GIO_USE_VFS", "local", TRUE);
g_setenv ("GSETTINGS_BACKEND", "memory", TRUE);
int
main (int argc, char **argv)
{
- /* These must be set before before gtk_test_init */
+ /* These must be set before gtk_test_init */
g_setenv ("GIO_USE_VFS", "local", TRUE);
g_setenv ("GSETTINGS_BACKEND", "memory", TRUE);
projects / gtk4.git / commitdiff